home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / programm.ing / m2gem106.lzh / CRYSTAL1.06 / SRC / CRYSTAL / VDI.MOD < prev    next >
Encoding:
Modula Implementation  |  1993-03-05  |  8.6 KB  |  455 lines
  1. IMPLEMENTATION MODULE VDI;
  2.  
  3. (*
  4. Global VDI Definitions.
  5.  
  6. UK __DATE__ __TIME__
  7. *)
  8.  
  9. (*IMP_SWITCHES*)
  10.  
  11. FROM PORTAB   IMPORT SIGNEDWORD,UNSIGNEDWORD;
  12. #if (defined LPRM2) || (defined SPCM2)
  13. FROM SYSTEM   IMPORT VAL,SETREG,ADR,INLINE;
  14. FROM Register IMPORT D1;
  15. #elif (defined TDIM2) || (defined ANAM2) || (defined FTLM2)
  16. FROM SYSTEM   IMPORT SETREG,ADR,CODE;
  17. FROM Register IMPORT D1;
  18. #elif (defined HM2)
  19. FROM SYSTEM   IMPORT LOAD,ADR,CODE;
  20. FROM Register IMPORT D1;
  21. #elif (defined MM2)
  22. FROM SYSTEM   IMPORT ASSEMBLER,CAST,ADR;
  23. #elif (defined FSTM2)
  24. FROM SYSTEM   IMPORT ADR,ASSEMBLER,SEGMENT,OFFSET;
  25. #elif (defined SDSM2)
  26. FROM SYSTEM   IMPORT CODE,RegDS,RegCX,RegDX,SWI,ADR,ADDRESS,WORD;
  27. #elif (defined LM2)
  28. FROM SYSTEM   IMPORT ADDRESS,CODE,SWI,SETREG,DX,CX,ADR;
  29. #elif (defined TSM2_1)
  30. FROM VDISYS   IMPORT callvdi;
  31. #elif (defined TSM2_2)
  32. FROM SYSTEM   IMPORT Seg,Ofs,BYTE,WORD,ADR;
  33. #endif
  34.  
  35. #if (defined LPRM2) || (defined SPCM2)
  36. PROCEDURE vdi;
  37.  
  38.   PROCEDURE Trap2;
  39.     CODE(04E42H);
  40.  
  41. BEGIN
  42.   SETREG(D1,ADR(v)); (* move.l #v,d1   *)
  43.   INLINE(7073H);     (* moveq  #$73,d0 *)
  44.   Trap2;             (* trap   #2      *)
  45. END vdi;
  46.  
  47. PROCEDURE CallVDI(opcode,nptsin,nintin,handle: UNSIGNEDWORD);
  48.  
  49.   PROCEDURE Trap2;
  50.     CODE(04E42H);
  51.  
  52. BEGIN
  53.   WITH contrl DO
  54.     c[0]:= opcode;
  55.     c[1]:= nptsin;
  56.     c[3]:= nintin;
  57.     c[6]:= handle;
  58.   END;
  59.   SETREG(D1,ADR(v));
  60.   INLINE(7073H);
  61.   Trap2;
  62. END CallVDI;
  63. #endif
  64.  
  65. #ifdef HM2
  66. PROCEDURE vdi;
  67.  
  68. CONST trap2 = 4E42H;
  69.  
  70. BEGIN
  71.   LOAD(ADR(v),D1); (* move.l #v,d1   *)
  72.   CODE(7073H);     (* moveq  #$73,d0 *)
  73.   CODE(trap2);     (* trap   #2      *)
  74. END vdi;
  75.  
  76. PROCEDURE CallVDI(opcode,nptsin,nintin,handle: UNSIGNEDWORD);
  77.  
  78. CONST trap2 = 4E42H;
  79.  
  80. BEGIN
  81.   WITH contrl DO
  82.     c[0]:= opcode;
  83.     c[1]:= nptsin;
  84.     c[3]:= nintin;
  85.     c[6]:= handle;
  86.   END;
  87.   LOAD(ADR(v),D1);
  88.   CODE(7073H);
  89.   CODE(trap2);
  90. END CallVDI;
  91. #endif
  92.  
  93. #if (defined TDIM2) || (defined FTLM2)
  94. PROCEDURE vdi;
  95.  
  96. CONST trap2 = 4E42H;
  97.  
  98. BEGIN
  99.   SETREG(D1,ADR(v)); (* move.l #v,d1   *)
  100.   CODE(7073H);       (* moveq  #$73,d0 *)
  101.   CODE(trap2);       (* trap   #2      *)
  102. END vdi;
  103.  
  104. PROCEDURE CallVDI(opcode,nptsin,nintin,handle: UNSIGNEDWORD);
  105.  
  106. CONST trap2 = 4E42H;
  107.  
  108. BEGIN
  109.   WITH contrl DO
  110.     c[0]:= opcode;
  111.     c[1]:= nptsin;
  112.     c[3]:= nintin;
  113.     c[6]:= handle;
  114.   END;
  115.   SETREG(D1,ADR(v));
  116.   CODE(7073H);
  117.   CODE(trap2);
  118. END CallVDI;
  119. #endif
  120.  
  121. #ifdef ANAM2
  122. PROCEDURE vdi;
  123.  
  124. CONST trap2 = 4E42H;
  125.  
  126. BEGIN
  127.   SETREG(D1,ADR(v)); (* move.l #v,d1   *)
  128.   CODE(7073H);       (* moveq  #$73,d0 *)
  129.   CODE(trap2);       (* trap   #2      *)
  130. END vdi;
  131.  
  132. PROCEDURE CallVDI(opcode,nptsin,nintin,handle: UNSIGNEDWORD);
  133.  
  134. CONST trap2 = 4E42H;
  135.  
  136. BEGIN
  137.   WITH contrl DO
  138.     c[0]:= CAST(UNSIGNEDWORD,opcode);
  139.     c[1]:= CAST(UNSIGNEDWORD,nptsin);
  140.     c[3]:= CAST(UNSIGNEDWORD,nintin);
  141.     c[6]:= CAST(UNSIGNEDWORD,handle);
  142.   END;
  143.   SETREG(D1,ADR(v));
  144.   CODE(7073H);
  145.   CODE(trap2);
  146. END CallVDI;
  147. #endif
  148.  
  149. #ifdef MM2
  150. PROCEDURE vdi;
  151. (*$L-*)
  152. BEGIN
  153.   ASSEMBLER
  154.     MOVE.L #v,D1;
  155.     MOVEQ  #$73,D0;
  156.     TRAP   #2;
  157.   END;
  158. END vdi;
  159. (*$L=*)
  160.  
  161. PROCEDURE CallVDI(opcode,nptsin,nintin,handle: UNSIGNEDWORD);
  162. BEGIN
  163.   WITH contrl DO
  164.     c[0]:= opcode;
  165.     c[1]:= nptsin;
  166.     c[3]:= nintin;
  167.     c[6]:= handle;
  168.   END;
  169.   vdi;
  170. END CallVDI;
  171. #endif
  172.  
  173. #ifdef MSM2
  174. (* $L- *)
  175. PROCEDURE vdi;
  176. BEGIN
  177.   (*$A+*)
  178.     MOVE.L #v,D1
  179.     MOVEQ  #$73,D0
  180.     TRAP   #2
  181.   (*$A-*)
  182. END vdi;
  183. (* $L+ *)
  184.  
  185. PROCEDURE CallVDI(opcode,nptsin,nintin,handle: UNSIGNEDWORD);
  186. BEGIN
  187.   WITH contrl DO
  188.     c[0]:= opcode;
  189.     c[1]:= nptsin;
  190.     c[3]:= nintin;
  191.     c[6]:= handle;
  192.   END;
  193.   (*$A+*)
  194.     MOVE.L #v,D1
  195.     MOVEQ  #$73,D0
  196.     TRAP   #2
  197.   (*$A-*)
  198. END CallVDI;
  199. #endif
  200.  
  201. #ifdef FSTM2
  202.   MODULE SystemCall;
  203.  
  204.   IMPORT ASSEMBLER,SEGMENT,OFFSET,UNSIGNEDWORD,contrl,v;
  205.   EXPORT vdi,CallVDI;
  206.  
  207.   VAR VDIPBSEG: CARDINAL;
  208.       VDIPBOFS: CARDINAL;
  209.  
  210.   PROCEDURE vdi;
  211.  
  212.   CONST GEM    = 0EFH;
  213.         OpCode = 473H;
  214.  
  215.   BEGIN
  216.     ASM
  217.       PUSH DS
  218.       MOV  DS,VDIPBSEG
  219.       MOV  DX,VDIPBOFS
  220.       MOV  CX,OpCode
  221.       INT  GEM
  222.       POP  DS
  223.     END;
  224.   END vdi;
  225.  
  226.   PROCEDURE CallVDI(opcode,nptsin,nintin,handle: UNSIGNEDWORD);
  227.   BEGIN
  228.     WITH contrl DO
  229.       c[0]:= opcode;
  230.       c[1]:= nptsin;
  231.       c[3]:= nintin;
  232.       c[6]:= handle;
  233.     END;
  234.     vdi;
  235.   END CallVDI;
  236.  
  237.   BEGIN
  238.     VDIPBSEG:= SEGMENT(v);
  239.     VDIPBOFS:= OFFSET(v);
  240.   END SystemCall;
  241. #endif
  242.  
  243. #ifdef LM2
  244. PROCEDURE vdi;
  245.  
  246. CONST OpCode = 1139;
  247.       GEM    = 0EFH;
  248.  
  249. TYPE Address = RECORD
  250.                  CASE: BOOLEAN OF
  251.                    TRUE:
  252.                      Adr: ADDRESS;
  253.                  | FALSE:
  254.                      Ofs: CARDINAL;
  255.                      Seg: CARDINAL;
  256.                  END;
  257.                END;
  258.  
  259. VAR VDIPBADR: Address;
  260.     VDIPBSEG: CARDINAL;
  261.     VDIPBOFS: CARDINAL;
  262.  
  263. BEGIN
  264.   VDIPBADR.Adr:= ADR(v);
  265.  
  266.   VDIPBSEG:= VDIPBADR.Seg;
  267.   VDIPBOFS:= VDIPBADR.Ofs;
  268.  
  269.   CODE(1EH);               (* push ds     *)
  270.   SETREG(DX,VDIPBSEG);
  271.   CODE(08EH,0DAH);         (* mov ds,dx   *)
  272.   SETREG(DX,VDIPBOFS);
  273.   SETREG(CX,OpCode);       (* mov cx,1139 *)
  274.   SWI(GEM);                (* int GEM     *)
  275.   CODE(1FH);               (* pop ds      *)
  276. END vdi;
  277.  
  278. PROCEDURE CallVDI(opcode,nptsin,nintin,handle: UNSIGNEDWORD);
  279. BEGIN
  280.   WITH contrl DO
  281.     c[0]:= opcode;
  282.     c[1]:= nptsin;
  283.     c[3]:= nintin;
  284.     c[6]:= handle;
  285.   END;
  286.   vdi;
  287. END CallVDI;
  288. #endif
  289.  
  290. #ifdef SDSM2
  291. PROCEDURE vdi;
  292.  
  293. CONST OpCode = 1139;
  294.       GEM    = 0EFH;
  295.  
  296. TYPE Address = RECORD
  297.                  CASE: BOOLEAN OF
  298.                    TRUE:
  299.                      Adr: ADDRESS;
  300.                  | FALSE:
  301.                      Ofs: WORD;
  302.                      Seg: WORD;
  303.                  END;
  304.                END;
  305.  
  306. VAR VDIPBADR: Address;
  307.     VDIPBSEG: WORD;
  308.     VDIPBOFS: WORD;
  309.  
  310. BEGIN
  311.   VDIPBADR.Adr:= ADR(v);
  312.  
  313.   VDIPBSEG:= VDIPBADR.Seg;
  314.   VDIPBOFS:= VDIPBADR.Ofs;
  315.  
  316.   CODE(1EH);        (* push ds     *)
  317.   RegDS:= VDIPBSEG;
  318.   RegDX:= VDIPBOFS;
  319.   RegCX:= OpCode;   (* mov cx,1139 *)
  320.   SWI(GEM);         (* int GEM     *)
  321.   CODE(1FH);        (* pop ds      *)
  322. END vdi;
  323.  
  324. PROCEDURE CallVDI(opcode,nptsin,nintin,handle: UNSIGNEDWORD);
  325. BEGIN
  326.   WITH contrl DO
  327.     c[0]:= opcode;
  328.     c[1]:= nptsin;
  329.     c[3]:= nintin;
  330.     c[6]:= handle;
  331.   END;
  332.   vdi;
  333. END CallVDI;
  334. #endif
  335.  
  336. #ifdef TSM2_1
  337.   MODULE SystemCall;
  338.  
  339.   IMPORT v,contrl,UNSIGNEDWORD,callvdi;
  340.   IMPORT vdi,CallVDI; (* EXPORT *)
  341.  
  342.   PROCEDURE vdi;
  343.   BEGIN
  344.     callvdi(v);
  345.   END vdi;
  346.  
  347.   PROCEDURE CallVDI(opcode,nptsin,nintin,handle: UNSIGNEDWORD);
  348.   BEGIN
  349.     WITH contrl DO
  350.       c[0]:= opcode;
  351.       c[1]:= nptsin;
  352.       c[3]:= nintin;
  353.       c[6]:= handle;
  354.     END;
  355.     callvdi(v);
  356.   END CallVDI;
  357.  
  358.   END SystemCall;
  359. #endif
  360.  
  361. #ifdef TSM2_2
  362.   MODULE SystemCall;
  363.  
  364.   IMPORT v,contrl,UNSIGNEDWORD,BYTE,WORD,Seg,Ofs;
  365.   IMPORT vdi,CallVDI; (* EXPORT *)
  366.  
  367.   PROCEDURE vdi;
  368.  
  369.   CONST OpCode = 473H;
  370.         GEM    = 0EFH;
  371.  
  372.   TYPE CODE1 = ARRAY[0..0] OF BYTE;
  373.        CODE2 = ARRAY[0..1] OF BYTE;
  374.        CODE5 = ARRAY[0..4] OF BYTE;
  375.  
  376.     (*#save *)
  377.     (*#call(inline=>on,
  378.             reg_param=>(dx) *)
  379.     PROCEDURE push_ds = CODE1(01EH); (* push ds *)
  380.  
  381.     PROCEDURE pop_ds = CODE1(01FH); (* pop ds *)
  382.  
  383.     PROCEDURE mov_seg(a: WORD) = CODE2(08EH,0DAH); (* mov ds,dx *)
  384.  
  385.     PROCEDURE callvdi(a: WORD) = CODE5(0B9H,073H,004H, (* mov cx,473h *)
  386.                                        0CDH,GEM);      (* int GEM     *)
  387.     (*#restore *)
  388.  
  389.   BEGIN
  390.     push_ds;         (* push ds      *)
  391.     mov_seg(Seg(v)); (* mov dx,seg v *)
  392.                      (* mov ds,dx    *)
  393.     callvdi(Ofs(v)); (* mov dx,ofs v *)
  394.                      (* mov cx,0473h *)
  395.                      (* int 0efh     *)
  396.     pop_ds;          (* pop ds       *)
  397.   END vdi;
  398.  
  399.   PROCEDURE CallVDI(opcode,nptsin,nintin,handle: UNSIGNEDWORD);
  400.   BEGIN
  401.     WITH contrl DO
  402.       c[0]:= opcode;
  403.       c[1]:= nptsin;
  404.       c[3]:= nintin;
  405.       c[6]:= handle;
  406.     END;
  407.     vdi;
  408.   END CallVDI;
  409.  
  410.   END SystemCall;
  411. #endif
  412.  
  413. PROCEDURE CallEsc(escno,handle: UNSIGNEDWORD);
  414. BEGIN
  415.   WITH contrl DO
  416.     c[0]:= 5;
  417.     c[1]:= 0;
  418.     c[3]:= 0;
  419.     c[5]:= escno;
  420.     c[6]:= handle;
  421.   END;
  422.   vdi;
  423. END CallEsc;
  424.  
  425. PROCEDURE CallVDIEsc(escno,nptsin,nintin,handle: UNSIGNEDWORD);
  426. BEGIN
  427.   WITH contrl DO
  428.     c[0]:= 5;
  429.     c[1]:= nptsin;
  430.     c[3]:= nintin;
  431.     c[5]:= escno;
  432.     c[6]:= handle;
  433.   END;
  434.   vdi;
  435. END CallVDIEsc;
  436.  
  437. PROCEDURE Result(): SIGNEDWORD;
  438. BEGIN
  439.   RETURN intout[0];
  440. END Result;
  441.  
  442. BEGIN
  443.  
  444.   (* initialization of VDI parameter block *)
  445.  
  446.   WITH v DO
  447.     pblock:= ADR(contrl);
  448.     iioff:= ADR(intin);
  449.     pioff:= ADR(ptsin);
  450.     iooff:= ADR(intout);
  451.     pooff:= ADR(ptsout);
  452.   END;
  453.  
  454. END VDI.
  455.